#include "direccionamiento_FAT.h"
#include <fcntl.h>
/*____________________________________________________*/

int convertir_Pedido(int numBloque) {

	int numSectorIni;
	int distancia = 1;
	numSectorIni = numBloque+numBloque * distancia;

	return numSectorIni;

}

/*____________________________________________________*/

int realizar_pedido_lectura(int numBloque, char* datos){
	int i,sock=0;
	char* buff1=malloc(519);
	memset(buff1,0,519);
	NIPC pack,pack2;



	for(i=0;i<cantConexiones;i++)
		if(vectorSocket[i]!=0){
			down(mutexSock);
			sock=vectorSocket[i];
			vectorSocket[i]=0;
			up(mutexSock);
			break;
		}


	if(sock==0){
		while(sock==0)
		for(i=0;i<cantConexiones;i++)
				if(vectorSocket[i]!=0){
					down(mutexSock);
					sock=vectorSocket[i];
					vectorSocket[i]=0;
					up(mutexSock);
					break;
				}

	}

	uint32_t sectorIni;

	sectorIni=convertir_Pedido(numBloque);
	pack.mensaje=malloc(sizeof (uint32_t));
	pack2.mensaje=malloc(sizeof (uint32_t));
	char miniV[sizeof(uint32_t)];
	memset(miniV,0,sizeof(uint32_t));
	memcpy(miniV,&sectorIni,sizeof(uint32_t));
	cargarEstructura(&pack,1,miniV);

	char vector[pack.payloadLength+3];

memset(vector,0,pack.payloadLength+3);

	serializar_NIPC(pack,vector);

	int count=0;
	 int res=0;

	enviarDatos(vector,pack.payloadLength+3,sock);
	int sector=sectorIni;
res=recv(sock,buff1+res,519,0);
if(buff1[0]!='1'){
		res=0;
		memset(buff1,0,519);
	}
else{
	int id=0,lon=0,sect=0;
				memcpy(&lon,buff1+1,sizeof(uint16_t));
				memcpy(&id,buff1,sizeof(uint8_t));
				memcpy(&sect,buff1+3+512,sizeof(uint32_t));
				if(id==1&&sect==sector){
					memcpy(datos,buff1+3,512);
					count++;
				}
				else if(id==1&&sect==(sector+1)){
					memcpy(datos+512,buff1+3,512);
					count++;
				}

					memset(buff1,519,0);
					res=0;

}
	sectorIni++;
	memset(miniV,0,sizeof(uint32_t));
	memcpy(miniV,&sectorIni,sizeof(uint32_t));
	cargarEstructura(&pack2,2,miniV);
    char vector2[pack2.payloadLength+3];
	memset(vector,0,pack2.payloadLength+3);
	serializar_NIPC(pack2,vector2);
	enviarDatos(vector2,pack2.payloadLength+3,sock);


	memset(datos,1024,0);
	while( count<2) {
		(res=recv(sock,buff1,519,0));


				int id=0,lon=0,sect=0;
				memcpy(&lon,buff1+1,sizeof(uint16_t));
				memcpy(&id,buff1,sizeof(uint8_t));
				memcpy(&sect,buff1+3+512,sizeof(uint32_t));
				if(id==1&&sect==sector){
					memcpy(datos,buff1+3,512);
					count++;
				}
				else if(id==1&&sect==(sector+1)){
					memcpy(datos+512,buff1+3,512);
					count++;
				}

					memset(buff1,519,0);
					res=0;
	}
	down(mutexSock);
	vectorSocket[i]=sock;
	up(mutexSock);

	//parsearResultadoLectura(buffer,datos,sectorIni-1);

	////////////////////////////////



///////////////////////////////////////////

	free(pack.mensaje);
	free(pack2.mensaje);

	res=0;
	return 0;
}

/*____________________________________________________*/

int realizar_pedido_escritura(int numBloque, char* datos){
	int i,sock=0;
		char* buff1=malloc(519);
		memset(buff1,0,519);
		NIPC pack,pack2;



		for(i=0;i<cantConexiones;i++)
			if(vectorSocket[i]!=0){
				down(mutexSock);
				sock=vectorSocket[i];
				vectorSocket[i]=0;
				up(mutexSock);
				break;
			}

	if(sock==0){
			while(sock==0){

				for(i=0;i<cantConexiones;i++)
					if(vectorSocket[i]!=0){
						down(mutexSock);
						sock=vectorSocket[i];
						vectorSocket[i]=0;
						up(mutexSock);
						break;
					}

			}
		}

		uint32_t sectorIni;

		sectorIni=convertir_Pedido(numBloque);
		pack.mensaje=malloc(sizeof (uint32_t));
		pack2.mensaje=malloc(sizeof (uint32_t));
		char miniV[sizeof(uint32_t)+512];
		memset(miniV,0,sizeof(uint32_t)+512);
		memcpy(miniV,datos,512);
		memcpy(miniV+512,&sectorIni,sizeof(uint32_t));
		cargarEstructura(&pack,3,miniV);

		char vector[pack.payloadLength+3];

	memset(vector,0,pack.payloadLength+3);

		serializar_NIPC(pack,vector);

		int count=0;
		 int res=0;

		enviarDatos(vector,pack.payloadLength+3,sock);

res=recv(sock,buff1+res,519,0);
	if(buff1[0]!='3'){
			res=0;
			memset(buff1,0,519);
		}
	else{
		int id=0,lon=0,sect=0;
					memcpy(&lon,buff1+1,sizeof(uint16_t));
					memcpy(&id,buff1,sizeof(uint8_t));
					memcpy(&sect,buff1+3+512,sizeof(uint32_t));
					if(id=='O'){

						count++;
					}

						memset(buff1,519,0);
						res=0;

	}
		sectorIni++;
		memset(miniV,0,sizeof(uint32_t)+512);
		memcpy(miniV,datos+512,512);
		memcpy(miniV+512,&sectorIni,sizeof(uint32_t));
		cargarEstructura(&pack2,4,miniV);
	    char vector2[pack2.payloadLength+3];
		memset(vector,0,pack2.payloadLength+3);
		serializar_NIPC(pack2,vector2);
		enviarDatos(vector2,pack2.payloadLength+3,sock);


		//memset(datos,1024,0);
		while( count<2) {
			res=recv(sock,buff1,519,0);


					int id=0,lon=0,sect=0;
					memcpy(&lon,buff1+1,sizeof(uint16_t));
					memcpy(&id,buff1,sizeof(uint8_t));
					memcpy(&sect,buff1+3+512,sizeof(uint32_t));
					if(id=='O'){

						count++;
					}



						memset(buff1,519,0);
						res=0;
		}
		down(mutexSock);
		vectorSocket[i]=sock;
		up(mutexSock);
		return 0;

}
/*____________________________________________________*/

int parsearResultadoLectura(char*buffer,char*datos,int sector){
memset(datos,1024,0);
	int id,lon,sect;
	memcpy(&lon,buffer+1,sizeof(uint16_t));
	memcpy(&id,buffer,sizeof(uint8_t));
	memcpy(&sect,buffer+3+512,sizeof(uint32_t));
	if(id==1&&sect==sector)
		memcpy(datos,buffer+3,512);
	else if(id==1&&sect==(sector+1))
		memcpy(datos+512,buffer+3,512);

	else
		return 1;
	memcpy(&lon,buffer+1+512+3+4,sizeof(uint16_t));
	memcpy(&id,buffer+512+3+4,sizeof(uint8_t));


		if(id==1&&sect==sector)
			memcpy(datos,buffer+515+4+3,512);
		else if(id==1&&sect==sector)
			memcpy(datos+512,buffer+515+4+3,512);
		else
			return 1;



	return 0;
}

int parsearResultadoEscritura(char*buffer){
	int id,id2,lon;
	/*memcpy(&lon,buffer+1,sizeof(uint16_t));
	memcpy(&id,buffer,sizeof(uint8_t));
	if((id!=3&&id!=4)||lon!=0)
		return 1;
		else{
			memcpy(&lon,buffer+1+lon,sizeof(uint16_t));
			memcpy(&id2,buffer+lon,sizeof(uint8_t));
			if(((id2!=3&&id2!=4)||lon!=0)||id2==id)
				return 1;
			else
				return 0;
		}
*/
	return 0;
}
